home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / plot3d / token.m < prev    next >
Encoding:
Text File  |  1991-07-19  |  12.7 KB  |  622 lines
  1. # include "stdio.h"
  2. # define U(x) x
  3. # define NLSTATE yyprevious=YYNEWLINE
  4. # define BEGIN yybgin = yysvec + 1 +
  5. # define INITIAL 0
  6. # define YYLERR yysvec
  7. # define YYSTATE (yyestate-yysvec-1)
  8. # define YYOPTIM 1
  9. # define YYLMAX 200
  10. # define output(c) putc(c,yyout)
  11. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  12. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  13. # define yymore() (yymorfg=1)
  14. # define ECHO fprintf(yyout, "%s",yytext)
  15. # define REJECT { nstr = yyreject(); goto yyfussy;}
  16. int yyleng; extern char yytext[];
  17. int yymorfg;
  18. extern char *yysptr, yysbuf[];
  19. int yytchar;
  20. FILE *yyin ={stdin}, *yyout ={stdout};
  21. extern int yylineno;
  22. struct yysvf { 
  23.     struct yywork *yystoff;
  24.     struct yysvf *yyother;
  25.     int *yystops;};
  26. struct yysvf *yyestate;
  27. extern struct yysvf yysvec[], *yybgin;
  28. /*
  29.     token.lm
  30.  
  31.     This file defines the tokens that the Expression grammar is built on.  To
  32.     fully understand this file, you will need to understand lex.  The basic
  33.     idea is that lex scans a text stream and breaks that stream up into tokens
  34.     which are then fed to the grammar (defined in yacc).  Whitespace is ignored
  35.     so the grammar is just fed a steady stream of significant tokens.
  36. */
  37.  
  38. /*
  39.  * These are the routines lex calls to get another character as it parses.
  40.  * By default they are macros which read from stdin. We toss the default
  41.  * macro definitions and supply our own versions of these, which will feed
  42.  * lex characters from the expression string we are parsing.
  43.  */
  44. #undef input
  45. #undef unput
  46. #undef output
  47. static int input();
  48. static void unput(char c);
  49. static void output(char c);
  50.  
  51. #import <stdlib.h>
  52. #import <string.h>
  53. #import <math.h>
  54. #import "exprDefs.h"
  55. #import "y.tab.h"
  56.  
  57. /* global which holds the string we are parsing */
  58. static const char *CurrText;
  59.  
  60. /* glue to get rid of compiler warnings */
  61. extern yylook(), yyback();
  62. static int yywrap();
  63. # define YYNEWLINE 10
  64. int yylex(){
  65. int nstr; extern int yyprevious;
  66. while((nstr = yylook()) >= 0)
  67. yyfussy: switch(nstr){
  68. case 0:
  69. if(yywrap()) return(0); break;
  70. case 1:
  71. {        /* whitespace - we ignore it */
  72.     ;
  73. }
  74. break;
  75. case 2:
  76. {        /* an integer */
  77.     yylval.integer = atoi(yytext);
  78.     return INTEGER;
  79. }
  80. break;
  81. case 3:
  82. {                   /* a float */
  83.     yylval.real = atof(yytext);
  84.     return NUMBER;
  85. }
  86. break;
  87. case 4:
  88. {    /* a radix number */
  89.     int radix;
  90.     register int mult = 1;
  91.     register char *c, *stop;
  92.     register unsigned int accum = 0;
  93.     register int charVal;
  94.  
  95.     sscanf( yytext, "%d#", &radix );
  96.     for( stop = yytext; *stop++ != '#'; ); /* skip the pound sign */
  97.     for( c = yytext+yyleng-1; c >= stop; c--, mult *= radix ) {
  98.         if( *c >= '0' && *c <= '9' )
  99.         charVal = *c - '0';
  100.         else if( *c >= 'A' && *c <= 'Z' )
  101.         charVal = *c - 'A' + 10;
  102.         else
  103.         charVal = *c - 'a' + 10;
  104.         accum += mult * charVal;
  105.     }
  106.     yylval.real = accum;
  107.     return NUMBER;
  108. }
  109. break;
  110. case 5:
  111. {            /* the constant pi */
  112.     yylval.real = M_PI;
  113.     return NUMBER;
  114. }
  115. break;
  116. case 6:
  117. {            /* the constant e */
  118.     yylval.real = M_E;
  119.     return NUMBER;
  120. }
  121. break;
  122. case 7:
  123.  {            /* a single char that must be recognized */
  124.     return yytext[0];
  125. }
  126. break;
  127. case 8:
  128. {    /* an identifier */
  129.     yylval.string = NXZoneMalloc(NXDefaultMallocZone(), yyleng+1); 
  130.     bcopy(yytext, yylval.string, yyleng);
  131.     yylval.string[yyleng] = '\0';
  132.     return IDENTIFIER;
  133. }
  134. break;
  135. case 9:
  136. {        /* other garbage chars (last rule is the default) */
  137.     yylval.character = yytext[0];
  138.     return BADCHAR;
  139. }
  140. break;
  141. case -1:
  142. break;
  143. default:
  144. fprintf(yyout,"bad switch yylook %d",nstr);
  145. } return(0); }
  146. /* end of yylex */
  147.  
  148. /* inits the global string to the one we will parse */
  149. void _EXPPrepareToScan(const char *text)
  150. {
  151.     CurrText = text;
  152. }
  153.  
  154. /* tells lex there's really no more input when we're done */
  155. static int yywrap()
  156. {
  157.     return 1;
  158. }
  159.  
  160. /* returns the next char of the string we're parsing */
  161. static int input()
  162. {
  163.     return *CurrText++;
  164. }
  165.  
  166. /* lets lex back up one char in the string we're parsing */
  167. static void unput(char c)
  168. {
  169.     --CurrText;
  170. }
  171.  
  172. /* called by lex when it wants to output a char.  This should never happen. */
  173. static void output(char c)
  174. {
  175.     fprintf(stderr, "lex output function called with char '%c'\n", c);
  176. }
  177. int yyvstop[] ={
  178. 0,
  179.  
  180. 9,
  181. 0,
  182.  
  183. 1,
  184. 9,
  185. 0,
  186.  
  187. 1,
  188. 0,
  189.  
  190. 7,
  191. 9,
  192. 0,
  193.  
  194. 7,
  195. 9,
  196. 0,
  197.  
  198. 9,
  199. 0,
  200.  
  201. 2,
  202. 9,
  203. 0,
  204.  
  205. 8,
  206. 9,
  207. 0,
  208.  
  209. 6,
  210. 8,
  211. 9,
  212. 0,
  213.  
  214. 8,
  215. 9,
  216. 0,
  217.  
  218. 3,
  219. 0,
  220.  
  221. 3,
  222. 0,
  223.  
  224. 2,
  225. 0,
  226.  
  227. 8,
  228. 0,
  229.  
  230. 5,
  231. 8,
  232. 0,
  233.  
  234. 4,
  235. 0,
  236.  
  237. 3,
  238. 0,
  239.  
  240. 3,
  241. 0,
  242.  
  243. 3,
  244. 0,
  245.  
  246. 3,
  247. 0,
  248.  
  249. 3,
  250. 0,
  251. 0};
  252. # define YYTYPE unsigned char
  253. struct yywork { YYTYPE verify, advance; } yycrank[] ={
  254. 0,0,    0,0,    1,3,    0,0,    
  255. 0,0,    0,0,    0,0,    0,0,    
  256. 0,0,    0,0,    1,4,    1,5,    
  257. 4,5,    4,5,    0,0,    0,0,    
  258. 0,0,    0,0,    0,0,    0,0,    
  259. 0,0,    0,0,    0,0,    0,0,    
  260. 0,0,    0,0,    0,0,    0,0,    
  261. 0,0,    0,0,    0,0,    0,0,    
  262. 0,0,    0,0,    0,0,    4,5,    
  263. 0,0,    0,0,    1,6,    0,0,    
  264. 0,0,    0,0,    0,0,    0,0,    
  265. 1,7,    0,0,    0,0,    1,8,    
  266. 2,8,    1,9,    7,13,    0,0,    
  267. 7,14,    7,14,    7,14,    7,14,    
  268. 7,14,    7,14,    7,14,    7,14,    
  269. 7,14,    7,14,    0,0,    0,0,    
  270. 0,0,    0,0,    1,10,    0,0,    
  271. 0,0,    0,0,    1,10,    8,15,    
  272. 8,15,    8,15,    8,15,    8,15,    
  273. 8,15,    8,15,    8,15,    8,15,    
  274. 8,15,    0,0,    0,0,    0,0,    
  275. 0,0,    0,0,    17,24,    17,24,    
  276. 17,24,    17,24,    17,24,    17,24,    
  277. 17,24,    17,24,    17,24,    17,24,    
  278. 1,10,    0,0,    0,0,    0,0,    
  279. 0,0,    0,0,    1,11,    2,11,    
  280. 9,16,    15,22,    0,0,    17,25,    
  281. 24,30,    0,0,    0,0,    0,0,    
  282. 0,0,    1,12,    2,12,    9,17,    
  283. 12,21,    9,18,    9,18,    9,18,    
  284. 9,18,    9,18,    9,18,    9,18,    
  285. 9,18,    9,18,    9,18,    10,20,    
  286. 10,20,    10,20,    10,20,    10,20,    
  287. 10,20,    10,20,    10,20,    10,20,    
  288. 10,20,    15,22,    9,19,    17,25,    
  289. 24,30,    0,0,    0,0,    0,0,    
  290. 10,20,    10,20,    10,20,    10,20,    
  291. 10,20,    10,20,    10,20,    10,20,    
  292. 10,20,    10,20,    10,20,    10,20,    
  293. 10,20,    10,20,    10,20,    10,20,    
  294. 10,20,    10,20,    10,20,    10,20,    
  295. 10,20,    10,20,    10,20,    10,20,    
  296. 10,20,    10,20,    9,19,    0,0,    
  297. 0,0,    0,0,    10,20,    0,0,    
  298. 10,20,    10,20,    10,20,    10,20,    
  299. 10,20,    10,20,    10,20,    10,20,    
  300. 10,20,    10,20,    10,20,    10,20,    
  301. 10,20,    10,20,    10,20,    10,20,    
  302. 10,20,    10,20,    10,20,    10,20,    
  303. 10,20,    10,20,    10,20,    10,20,    
  304. 10,20,    10,20,    16,23,    16,23,    
  305. 16,23,    16,23,    16,23,    16,23,    
  306. 16,23,    16,23,    16,23,    16,23,    
  307. 0,0,    0,0,    0,0,    0,0,    
  308. 0,0,    0,0,    0,0,    16,23,    
  309. 16,23,    16,23,    16,23,    16,23,    
  310. 16,23,    16,23,    16,23,    16,23,    
  311. 16,23,    16,23,    16,23,    16,23,    
  312. 16,23,    16,23,    16,23,    16,23,    
  313. 16,23,    16,23,    16,23,    16,23,    
  314. 16,23,    16,23,    16,23,    16,23,    
  315. 16,23,    0,0,    0,0,    0,0,    
  316. 0,0,    0,0,    0,0,    16,23,    
  317. 16,23,    16,23,    16,23,    16,23,    
  318. 16,23,    16,23,    16,23,    16,23,    
  319. 16,23,    16,23,    16,23,    16,23,    
  320. 16,23,    16,23,    16,23,    16,23,    
  321. 16,23,    16,23,    16,23,    16,23,    
  322. 16,23,    16,23,    16,23,    16,23,    
  323. 16,23,    19,26,    0,0,    19,26,    
  324. 0,0,    0,0,    19,27,    19,27,    
  325. 19,27,    19,27,    19,27,    19,27,    
  326. 19,27,    19,27,    19,27,    19,27,    
  327. 22,28,    0,0,    22,28,    0,0,    
  328. 0,0,    22,29,    22,29,    22,29,    
  329. 22,29,    22,29,    22,29,    22,29,    
  330. 22,29,    22,29,    22,29,    25,31,    
  331. 0,0,    25,31,    0,0,    0,0,    
  332. 25,32,    25,32,    25,32,    25,32,    
  333. 25,32,    25,32,    25,32,    25,32,    
  334. 25,32,    25,32,    26,27,    26,27,    
  335. 26,27,    26,27,    26,27,    26,27,    
  336. 26,27,    26,27,    26,27,    26,27,    
  337. 28,29,    28,29,    28,29,    28,29,    
  338. 28,29,    28,29,    28,29,    28,29,    
  339. 28,29,    28,29,    30,33,    0,0,    
  340. 30,33,    0,0,    0,0,    30,34,    
  341. 30,34,    30,34,    30,34,    30,34,    
  342. 30,34,    30,34,    30,34,    30,34,    
  343. 30,34,    31,32,    31,32,    31,32,    
  344. 31,32,    31,32,    31,32,    31,32,    
  345. 31,32,    31,32,    31,32,    33,34,    
  346. 33,34,    33,34,    33,34,    33,34,    
  347. 33,34,    33,34,    33,34,    33,34,    
  348. 33,34,    0,0,    0,0,    0,0,    
  349. 0,0};
  350. struct yysvf yysvec[] ={
  351. 0,    0,    0,
  352. yycrank+-1,    0,        0,    
  353. yycrank+-2,    yysvec+1,    0,    
  354. yycrank+0,    0,        yyvstop+1,
  355. yycrank+3,    0,        yyvstop+3,
  356. yycrank+0,    yysvec+4,    yyvstop+6,
  357. yycrank+0,    0,        yyvstop+8,
  358. yycrank+4,    0,        yyvstop+11,
  359. yycrank+23,    0,        yyvstop+14,
  360. yycrank+69,    0,        yyvstop+16,
  361. yycrank+79,    0,        yyvstop+19,
  362. yycrank+0,    yysvec+10,    yyvstop+22,
  363. yycrank+11,    yysvec+10,    yyvstop+26,
  364. yycrank+0,    yysvec+8,    0,    
  365. yycrank+0,    yysvec+7,    0,    
  366. yycrank+36,    yysvec+8,    yyvstop+29,
  367. yycrank+154,    0,        0,    
  368. yycrank+38,    0,        yyvstop+31,
  369. yycrank+0,    yysvec+9,    yyvstop+33,
  370. yycrank+234,    0,        0,    
  371. yycrank+0,    yysvec+10,    yyvstop+35,
  372. yycrank+0,    yysvec+10,    yyvstop+37,
  373. yycrank+249,    0,        0,    
  374. yycrank+0,    yysvec+16,    yyvstop+40,
  375. yycrank+39,    yysvec+17,    yyvstop+42,
  376. yycrank+264,    0,        0,    
  377. yycrank+274,    0,        0,    
  378. yycrank+0,    yysvec+26,    yyvstop+44,
  379. yycrank+284,    0,        0,    
  380. yycrank+0,    yysvec+28,    yyvstop+46,
  381. yycrank+299,    0,        0,    
  382. yycrank+309,    0,        0,    
  383. yycrank+0,    yysvec+31,    yyvstop+48,
  384. yycrank+319,    0,        0,    
  385. yycrank+0,    yysvec+33,    yyvstop+50,
  386. 0,    0,    0};
  387. struct yywork *yytop = yycrank+376;
  388. struct yysvf *yybgin = yysvec+1;
  389. char yymatch[] ={
  390. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  391. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  392. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  393. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  394. 011 ,01  ,01  ,01  ,01  ,'%' ,01  ,01  ,
  395. '%' ,'%' ,'%' ,'+' ,01  ,'+' ,01  ,'%' ,
  396. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  397. '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  398. 01  ,'A' ,'A' ,'A' ,'A' ,'E' ,'A' ,'A' ,
  399. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  400. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  401. 'A' ,'A' ,'A' ,01  ,01  ,01  ,'%' ,'_' ,
  402. 01  ,'A' ,'A' ,'A' ,'A' ,'E' ,'A' ,'A' ,
  403. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  404. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  405. 'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
  406. 0};
  407. char yyextra[] ={
  408. 0,0,0,0,0,0,0,0,
  409. 0,0,0,0,0,0,0,0,
  410. 0};
  411. /*    ncform    4.1    83/08/11    */
  412.  
  413. int yylineno =1;
  414. # define YYU(x) x
  415. # define NLSTATE yyprevious=YYNEWLINE
  416. char yytext[YYLMAX];
  417. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  418. char yysbuf[YYLMAX];
  419. char *yysptr = yysbuf;
  420. int *yyfnd;
  421. extern struct yysvf *yyestate;
  422. int yyprevious = YYNEWLINE;
  423. #if    NeXT
  424. int yylook(){
  425. #else
  426. yylook(){
  427. #endif    NeXT
  428.     register struct yysvf *yystate, **lsp;
  429.     register struct yywork *yyt;
  430.     struct yysvf *yyz;
  431.     int yych;
  432.     struct yywork *yyr;
  433. # ifdef LEXDEBUG
  434.     int debug;
  435. # endif
  436.     char *yylastch;
  437.     /* start off machines */
  438. # ifdef LEXDEBUG
  439.     debug = 0;
  440. # endif
  441.     if (!yymorfg)
  442.         yylastch = yytext;
  443.     else {
  444.         yymorfg=0;
  445.         yylastch = yytext+yyleng;
  446.         }
  447.     for(;;){
  448.         lsp = yylstate;
  449.         yyestate = yystate = yybgin;
  450.         if (yyprevious==YYNEWLINE) yystate++;
  451.         for (;;){
  452. # ifdef LEXDEBUG
  453.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  454. # endif
  455.             yyt = yystate->yystoff;
  456.             if(yyt == yycrank){        /* may not be any transitions */
  457.                 yyz = yystate->yyother;
  458.                 if(yyz == 0)break;
  459.                 if(yyz->yystoff == yycrank)break;
  460.                 }
  461.             *yylastch++ = yych = input();
  462.         tryagain:
  463. # ifdef LEXDEBUG
  464.             if(debug){
  465.                 fprintf(yyout,"char ");
  466.                 allprint(yych);
  467.                 putchar('\n');
  468.                 }
  469. # endif
  470.             yyr = yyt;
  471.             if ( (int)yyt > (int)yycrank){
  472.                 yyt = yyr + yych;
  473.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  474.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  475.                         {unput(*--yylastch);break;}
  476.                     *lsp++ = yystate = yyt->advance+yysvec;
  477.                     goto contin;
  478.                     }
  479.                 }
  480. # ifdef YYOPTIM
  481.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  482.                 yyt = yyr = yycrank+(yycrank-yyt);
  483. # ifdef LEXDEBUG
  484.                 if(debug)fprintf(yyout,"compressed state\n");
  485. # endif
  486.                 yyt = yyt + yych;
  487.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  488.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  489.                         {unput(*--yylastch);break;}
  490.                     *lsp++ = yystate = yyt->advance+yysvec;
  491.                     goto contin;
  492.                     }
  493.                 yyt = yyr + YYU(yymatch[yych]);
  494. # ifdef LEXDEBUG
  495.                 if(debug){
  496.                     fprintf(yyout,"try fall back character ");
  497.                     allprint(YYU(yymatch[yych]));
  498.                     putchar('\n');
  499.                     }
  500. # endif
  501.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  502.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  503.                         {unput(*--yylastch);break;}
  504.                     *lsp++ = yystate = yyt->advance+yysvec;
  505.                     goto contin;
  506.                     }
  507.                 }
  508.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  509. # ifdef LEXDEBUG
  510.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  511. # endif
  512.                 goto tryagain;
  513.                 }
  514. # endif
  515.             else
  516.                 {unput(*--yylastch);break;}
  517.         contin:
  518. # ifdef LEXDEBUG
  519.             if(debug){
  520.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  521.                 allprint(yych);
  522.                 putchar('\n');
  523.                 }
  524. # endif
  525.             ;
  526.             }
  527. # ifdef LEXDEBUG
  528.         if(debug){
  529.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  530.             allprint(yych);
  531.             putchar('\n');
  532.             }
  533. # endif
  534.         while (lsp-- > yylstate){
  535.             *yylastch-- = 0;
  536.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  537.                 yyolsp = lsp;
  538.                 if(yyextra[*yyfnd]){        /* must backup */
  539.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  540.                         lsp--;
  541.                         unput(*yylastch--);
  542.                         }
  543.                     }
  544.                 yyprevious = YYU(*yylastch);
  545.                 yylsp = lsp;
  546.                 yyleng = yylastch-yytext+1;
  547.                 yytext[yyleng] = 0;
  548. # ifdef LEXDEBUG
  549.                 if(debug){
  550.                     fprintf(yyout,"\nmatch ");
  551.                     sprint(yytext);
  552.                     fprintf(yyout," action %d\n",*yyfnd);
  553.                     }
  554. # endif
  555.                 return(*yyfnd++);
  556.                 }
  557.             unput(*yylastch);
  558.             }
  559.         if (yytext[0] == 0  /* && feof(yyin) */)
  560.             {
  561.             yysptr=yysbuf;
  562.             return(0);
  563.             }
  564.         yyprevious = yytext[0] = input();
  565.         if (yyprevious>0)
  566.             output(yyprevious);
  567.         yylastch=yytext;
  568. # ifdef LEXDEBUG
  569.         if(debug)putchar('\n');
  570. # endif
  571.         }
  572.     }
  573. #if    NeXT
  574. int yyback(p, m)
  575.     int *p;
  576.     int m;
  577. #else
  578. yyback(p, m)
  579.     int *p;
  580. #endif    NeXT
  581. {
  582. if (p==0) return(0);
  583. while (*p)
  584.     {
  585.     if (*p++ == m)
  586.         return(1);
  587.     }
  588. return(0);
  589. }
  590.     /* the following are only used in the lex library */
  591. #if    NeXT
  592. int yyinput(){
  593. #else
  594. yyinput(){
  595. #endif    NeXT
  596.     return(input());
  597.     }
  598. #if    NeXT
  599. void yyoutput(c)
  600.     int c; 
  601. {
  602.     output(c);
  603. }
  604. #else
  605. yyoutput(c)
  606.   int c; {
  607.     output(c);
  608.     }
  609. #endif    NeXT
  610. #if    NeXT
  611. void yyunput(c)
  612.     int c; 
  613. {
  614.     unput(c);
  615. }
  616. #else
  617. yyunput(c)
  618.    int c; {
  619.     unput(c);
  620.     }
  621. #endif    NeXT
  622.